frontend/src/app/my/mentorship/programs/[programKey]/page.tsx (1)

32-37: Consider refining the loading state to avoid UI flicker during background refetch.

The fetchPolicy: 'cache-and-network' addition aligns well with the PR's cache invalidation objectives. However, combined with notifyOnNetworkStatusChange: true, the loading boolean will be true during background refetches, which could cause the LoadingSpinner to briefly replace existing content.

Consider checking for cached data presence or using networkStatus to distinguish initial load from background refetch:

Suggested improvement

-  const { data, loading: isQueryLoading } = useQuery(GetProgramAndModulesDocument, {
+  const { data, loading: isQueryLoading, networkStatus } = useQuery(GetProgramAndModulesDocument, {
     variables: { programKey },
     skip: !programKey,
     fetchPolicy: 'cache-and-network',
     notifyOnNetworkStatusChange: true,
   })
 
-  const isLoading = isQueryLoading
+  // Only show loading spinner on initial load, not background refetch
+  const isLoading = isQueryLoading && !data

This ensures the spinner only appears when there's no cached data to display, preventing flicker during background network requests.

frontend/src/app/mentorship/programs/[programKey]/modules/[moduleKey]/page.tsx (1)

32-39: Consider extracting duplicate isNotFound computation.

The same error.message?.toLowerCase().includes('not found') logic is computed both in the useEffect (line 34) and in the render block (line 44). While the overhead is negligible, extracting this to a single derived value improves maintainability.

♻️ Suggested refactor

+ const isNotFound = error?.message?.toLowerCase().includes('not found')
+
  useEffect(() => {
    if (error) {
-     const isNotFound = error.message?.toLowerCase().includes('not found')
      if (!isNotFound) {
        handleAppError(error)
      }
    }
- }, [error])
+ }, [error, isNotFound])

  if (isLoading) return <LoadingSpinner />

  if (error) {
-   const isNotFound = error.message?.toLowerCase().includes('not found')
    return (
      <ErrorDisplay
        statusCode={isNotFound ? 404 : 500}

Also applies to: 43-56

backend/apps/common/graphql_cache.py (2)

10-10: Consider adding debug logging for cache invalidation.

The logger is imported but unused. Adding debug-level logging in invalidate_graphql_cache would help diagnose cache issues in production.

♻️ Optional: Add debug logging

 def invalidate_graphql_cache(field_name: str, field_args: dict) -> bool:
     ...
     key = f"{field_name}:{json.dumps(field_args, sort_keys=True)}"
     cache_key = f"{settings.GRAPHQL_RESOLVER_CACHE_PREFIX}-{hashlib.sha256(key.encode()).hexdigest()}"
-    result = cache.delete(cache_key)
-    return result
+    deleted = cache.delete(cache_key)
+    logger.debug("Cache invalidation for %s: %s", field_name, "hit" if deleted else "miss")
+    return deleted

---

25-26: Minor: Simplify return statement.

Per static analysis (RET504), the intermediate assignment is unnecessary.

♻️ Suggested simplification

-    result = cache.delete(cache_key)
-    return result
+    return cache.delete(cache_key)

backend/apps/common/extensions.py (1)

105-106: Verify SchemaExtension can be instantiated without execution_context.

_cache_extension = CacheExtension() is created at import time. In Strawberry, SchemaExtension often expects an execution_context in __init__. If that’s required in v0.289.0, this will raise at startup. Consider refactoring invalidation helpers to avoid constructing SchemaExtension directly (e.g., extract a standalone key helper), or confirm the constructor accepts None.

backend/apps/mentorship/api/internal/mutations/module.py (1)

407-409: Same on-commit concern applies here.
Consider batching invalidation inside a single transaction.on_commit callback to prevent stale recache windows.

🔧 Suggested fix

-        invalidate_module_cache(old_module_key, module.program.key)
-        if module.key != old_module_key:
-            invalidate_module_cache(module.key, module.program.key)
+        def _invalidate():
+            invalidate_module_cache(old_module_key, module.program.key)
+            if module.key != old_module_key:
+                invalidate_module_cache(module.key, module.program.key)
+        transaction.on_commit(_invalidate)